home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1996 / MacHack 1996.toast / Hacks / Hacks '96 / Booting Gallery / Booting Gallery (source) / (Libraries) / Fluent Libraries / Heaps / HeapObjects.h < prev    next >
Encoding:
Text File  |  1996-06-22  |  3.3 KB  |  197 lines  |  [TEXT/BROW]
  1. // DynamicHeap.h
  2. // Created by Bill Hubauer on Thu, May 25, 1995 @ 8:00 AM.
  3.  
  4. #ifndef __HeapObjects__
  5. #define __HeapObjects__
  6.  
  7.  
  8. #ifndef _HEAPS_
  9. #include "Heaps.h"
  10. #endif
  11.  
  12. #ifndef __ObjectQueue__
  13. #include "ObjectQueue.h"
  14. #endif
  15.  
  16. class CHeap
  17. {
  18.     public:
  19.         CHeap() {}
  20.         virtual ~CHeap() {}
  21.         
  22.         Ptr        Allocate(Size size);
  23.         void    Free(Ptr block);
  24.         
  25.         virtual Boolean        HeapOK() = 0;
  26.         virtual Boolean        BlockInHeapQ(Ptr block) = 0;
  27.         
  28.         virtual Size        FreeSpace() = 0;
  29.         
  30.         virtual Size        BlockSize(Ptr block) = 0;
  31.  
  32.         virtual Size        GetUsedSize() = 0;
  33.         
  34.     protected:
  35.         virtual    Ptr        GetBlock(Size    size) = 0;
  36.         virtual void     FreeBlock(Ptr block) = 0;
  37.         
  38.         virtual Boolean    AllocateFailed(Size sizeNeeded) {return false;}
  39. };
  40.  
  41.  
  42.  
  43.  
  44. class CMacHeap : public CHeap
  45. {
  46. public:
  47.     CMacHeap(THz    zone);
  48.     CMacHeap();        // cur zone
  49.     virtual ~CMacHeap();
  50.  
  51.     virtual Boolean     HeapOK()                        {return true;}
  52.     virtual Boolean        BlockInHeapQ(Ptr block)        {return true;}
  53.     
  54.     virtual Size        FreeSpace();
  55.     virtual Size        BlockSize(Ptr block)    {return GetPtrSize(block); }
  56.  
  57.     virtual Size        GetUsedSize();
  58.  
  59.     
  60. protected:
  61.     virtual    Ptr        GetBlock(Size    size);
  62.     virtual void     FreeBlock(Ptr block);
  63.  
  64.     THz        _zone;
  65.     UInt32    _sizeUsed;        // my size used
  66.  
  67. };
  68.  
  69.  
  70.  
  71.  
  72. class CStaticHeap : public CHeap
  73. {
  74. public:
  75.     CStaticHeap(CHeap&    heapSource,Size    theSize);
  76.     CStaticHeap(Ptr heapArea,Size theSize);
  77.     virtual ~CStaticHeap();
  78.  
  79.     virtual Boolean            HeapOK()        {return _sHeap != NULL;}
  80.  
  81.     virtual Size        FreeSpace();
  82.     virtual Boolean        BlockInHeapQ(Ptr block);
  83.  
  84.     virtual Size        BlockSize(Ptr block)    {return SHeap::BlockSize(block); }
  85.     
  86.     virtual Size        GetUsedSize();
  87.  
  88. protected:
  89.     virtual    Ptr        GetBlock(Size    size);
  90.     virtual void     FreeBlock(Ptr block);
  91.     
  92.     void            Init(Ptr heapArea,Size theSize);
  93.  
  94.     Ptr                _heapArea;
  95.     Heap            _sHeap;
  96.     CHeap*            _heapSource;
  97.     
  98.     Ptr                _heapStart;
  99.     Ptr                _heapEnd;
  100. };
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107. class CDynamicHeap : public CHeap
  108. {
  109. public:
  110.     CDynamicHeap(CHeap&    heapSource,UInt32    initSize,UInt32 growSize);
  111.     virtual ~CDynamicHeap();
  112.  
  113.     virtual Boolean        HeapOK()        {return _ok;}
  114.     virtual Boolean        BlockInHeapQ(Ptr block);
  115.  
  116.     virtual Size        FreeSpace();
  117.  
  118.     virtual Size        BlockSize(Ptr block);
  119.  
  120.     void                CheckReservesMT();
  121.  
  122.     virtual Size        GetUsedSize();
  123.  
  124.  
  125. protected:
  126.     virtual Boolean    AllocateFailed(Size sizeNeeded);
  127.     virtual    Ptr        GetBlock(Size    size);
  128.     virtual void     FreeBlock(Ptr block);
  129.  
  130.     Ptr                GetBlockFromList(Size size);
  131.     CStaticHeap*    LocateHeapForBlock(Ptr block);
  132.  
  133.     UInt32            _initSize;
  134.     UInt32            _growSize;
  135.     
  136.     CObjectQueue    _heapList;
  137.     CStaticHeap*    _reserve;
  138.     Boolean            _ok;
  139.     
  140.     CHeap&            _heapSource;
  141.     
  142.     
  143.     // for debugging
  144.     UInt32            _hiHeapMark;
  145.     
  146. };
  147.  
  148.  
  149. class CManagedDynamicHeap;
  150.  
  151. class CHeapManager
  152. {
  153.     friend class CManagedDynamicHeap;
  154. public:
  155.     CHeapManager();
  156.     virtual ~CHeapManager();
  157.     
  158.     void    CheckReservesMT();
  159.     
  160.     CDynamicHeap*    MakeDynamicHeapMT(CHeap& heapSource,UInt32 initialSize,UInt32 growSize);
  161.     
  162. protected:
  163.     
  164.  
  165.  
  166.  
  167.     void    AddHeap(CManagedDynamicHeap*    heap);
  168.     void    RemoveHeap(CManagedDynamicHeap*    heap);
  169.     
  170.  
  171.     CObjectQueue            _heaps;
  172. };
  173.  
  174.  
  175.  
  176.  
  177. class    CManagedDynamicHeap:public CDynamicHeap,public MQueueElem
  178. {
  179.     friend class CHeapManager;
  180.     
  181.     public:
  182.     ~CManagedDynamicHeap() {_manager->RemoveHeap((CManagedDynamicHeap*)this);}
  183.     
  184.     protected:
  185.         CManagedDynamicHeap(CHeap& heapSource,UInt32 initialSize,UInt32 growSize,CHeapManager* manager)
  186.             :CDynamicHeap(heapSource,initialSize,growSize),_manager(manager) {manager->AddHeap(this);}
  187.         
  188.     
  189.         CHeapManager*    _manager;
  190.         
  191. };
  192.  
  193.  
  194.  
  195.  
  196. #endif
  197.